//package org.example;
//
//import lombok.extern.slf4j.Slf4j;
//import org.example.entity.CustomerInfo;
//import org.example.entity.CustomerOrder;
//import org.example.entity.CustomerRepayPlan;
//import org.example.generator.DataGenerator;
//import org.springframework.boot.CommandLineRunner;
//import org.springframework.boot.SpringApplication;
//import org.springframework.boot.autoconfigure.SpringBootApplication;
//
//import java.math.BigDecimal;
//import java.math.RoundingMode;
//import java.util.List;
//import java.util.Map;
//import java.util.stream.Collectors;
//
///**
// * 测试重新设计的数据生成器V2
// */
//@Slf4j
//@SpringBootApplication
//public class TestDataGeneratorV2 implements CommandLineRunner {
//
//    public static void main(String[] args) {
//        SpringApplication.run(TestDataGeneratorV2.class, args);
//    }
//
//    @Override
//    public void run(String... args) throws Exception {
//        log.info("开始测试重新设计的数据生成器V2 - 修复逾期逻辑bug");
//
//        try {
//            // 生成完整数据集
//            DataGenerator.DataGenerationResult result = DataGenerator.generateCompleteDataSet();
//
//            List<CustomerInfo> customers = result.getCustomers();
//            List<CustomerOrder> orders = result.getOrders();
//            List<CustomerRepayPlan> repayPlans = result.getRepayPlans();
//
//            log.info("=== 基础数据统计 ===");
//            log.info("客户数量: {}", customers.size());
//            log.info("订单数量: {}", orders.size());
//            log.info("还款计划数量: {}", repayPlans.size());
//
//            // 分析产品分布
//            Map<String, Long> productDistribution = orders.stream()
//                    .collect(Collectors.groupingBy(CustomerOrder::getProductName, Collectors.counting()));
//            log.info("产品分布: {}", productDistribution);
//
//            // 分析订单状态分布
//            Map<String, Long> statusDistribution = orders.stream()
//                    .collect(Collectors.groupingBy(CustomerOrder::getStatus, Collectors.counting()));
//            log.info("订单状态分布: {}", statusDistribution);
//
//            // 计算总放款金额
//            BigDecimal totalLoanAmount = orders.stream()
//                    .map(CustomerOrder::getLoanAmount)
//                    .reduce(BigDecimal.ZERO, BigDecimal::add);
//            log.info("总放款金额: {}", totalLoanAmount);
//
//            // 计算在途余额
//            BigDecimal outstandingAmount = orders.stream()
//                    .filter(order -> "未结清".equals(order.getStatus()))
//                    .map(CustomerOrder::getRemainPayAmount)
//                    .reduce(BigDecimal.ZERO, BigDecimal::add);
//            log.info("在途余额: {}", outstandingAmount);
//
//            // 分析浩瀚小贷的在途余额
//            BigDecimal haohanOutstanding = orders.stream()
//                    .filter(order -> "浩瀚小贷".equals(order.getProductName()) && "未结清".equals(order.getStatus()))
//                    .map(CustomerOrder::getRemainPayAmount)
//                    .reduce(BigDecimal.ZERO, BigDecimal::add);
//            log.info("浩瀚小贷在途余额: {}", haohanOutstanding);
//
//            // 验证浩瀚小贷在途余额不超过6万
//            if (haohanOutstanding.compareTo(new BigDecimal("60000")) > 0) {
//                log.warn("警告：浩瀚小贷在途余额超过6万！");
//            } else {
//                log.info("✓ 浩瀚小贷在途余额符合要求（≤6万）");
//            }
//
//            // 验证总在途余额接近20万
//            BigDecimal targetOutstanding = new BigDecimal("200000");
//            BigDecimal deviation = outstandingAmount.subtract(targetOutstanding).abs();
//            BigDecimal deviationRate = deviation.divide(targetOutstanding, 4, RoundingMode.HALF_UP);
//            if (deviationRate.compareTo(new BigDecimal("0.2")) > 0) { // 偏差超过20%
//                log.warn("警告：在途余额与目标20万偏差较大！");
//            } else {
//                log.info("✓ 在途余额符合要求（接近20万）");
//            }
//
//            // 分析还款计划状态
//            Map<String, Long> repayStatusDistribution = repayPlans.stream()
//                    .collect(Collectors.groupingBy(CustomerRepayPlan::getRepayStatus, Collectors.counting()));
//            log.info("还款计划状态分布: {}", repayStatusDistribution);
//
//            // 分析逾期情况
//            long overdueCount = repayPlans.stream()
//                    .filter(plan -> "逾期".equals(plan.getRepayStatus()))
//                    .count();
//            double overdueRate = (double) overdueCount / repayPlans.size() * 100;
//            log.info("逾期期数: {}, 逾期率: {:.2f}%", overdueCount, overdueRate);
//
//            // 验证逾期率在合理范围
//            if (overdueRate >= 3.0 && overdueRate <= 7.0) {
//                log.info("✓ 逾期率符合要求（3%-7%）");
//            } else {
//                log.warn("警告：逾期率不在预期范围（3%-7%）");
//            }
//
//            // 分析月度分布
//            Map<String, Long> monthlyDistribution = orders.stream()
//                    .collect(Collectors.groupingBy(
//                            order -> order.getFrTime().substring(0, 7), // 提取年月
//                            Collectors.counting()));
//            log.info("月度订单分布: {}", monthlyDistribution);
//
//            // 验证月度递增趋势
//            validateMonthlyIncrement(monthlyDistribution);
//
//            // 验证逾期后不能有已结清状态 - 重点验证
//            validateOverdueLogic(orders, repayPlans);
//
//            // 计算Vintage分析
//            log.info("=== Vintage分析 ===");
//            Map<String, DataGenerator.VintageAnalysis> vintageAnalysis =
//                    DataGenerator.calculateVintageAnalysis(orders, repayPlans);
//
//            for (Map.Entry<String, DataGenerator.VintageAnalysis> entry : vintageAnalysis.entrySet()) {
//                DataGenerator.VintageAnalysis analysis = entry.getValue();
//                log.info(analysis.toString());
//            }
//
//            // 验证Vintage逾期率
//            validateVintageRates(vintageAnalysis);
//
//            log.info("数据生成器V2测试完成 - 逾期逻辑bug已修复");
//
//        } catch (Exception e) {
//            log.error("测试过程中发生异常", e);
//        }
//    }
//
//    /**
//     * 验证月度递增趋势
//     */
//    private void validateMonthlyIncrement(Map<String, Long> monthlyDistribution) {
//        log.info("=== 验证月度递增趋势 ===");
//        List<Map.Entry<String, Long>> sortedEntries = monthlyDistribution.entrySet().stream()
//                .sorted(Map.Entry.comparingByKey())
//                .collect(Collectors.toList());
//
//        boolean isIncreasing = true;
//        for (int i = 1; i < sortedEntries.size(); i++) {
//            long prevCount = sortedEntries.get(i-1).getValue();
//            long currCount = sortedEntries.get(i).getValue();
//            if (currCount < prevCount) {
//                isIncreasing = false;
//                log.warn("警告：{} 月份订单数({})小于上月({})",
//                        sortedEntries.get(i).getKey(), currCount, prevCount);
//            }
//        }
//
//        if (isIncreasing) {
//            log.info("✓ 月度递增趋势符合要求");
//        }
//    }
//
//    /**
//     * 验证逾期后不能有已结清状态 - 重点验证
//     */
//    private void validateOverdueLogic(List<CustomerOrder> orders, List<CustomerRepayPlan> repayPlans) {
//        log.info("=== 验证逾期逻辑（重点验证） ===");
//
//        // 按订单分组还款计划
//        Map<String, List<CustomerRepayPlan>> orderPlans = repayPlans.stream()
//                .collect(Collectors.groupingBy(CustomerRepayPlan::getOrderNo));
//
//        int invalidOrders = 0;
//        int totalOrdersWithOverdue = 0;
//
//        for (CustomerOrder order : orders) {
//            List<CustomerRepayPlan> plans = orderPlans.get(order.getOrderNo());
//            if (plans != null) {
//                // 按期数排序
//                plans.sort((p1, p2) -> p1.getBillTenor().compareTo(p2.getBillTenor()));
//
//                boolean hasOverdue = false;
//                boolean hasSettledAfterOverdue = false;
//
//                for (CustomerRepayPlan plan : plans) {
//                    if ("逾期".equals(plan.getRepayStatus())) {
//                        hasOverdue = true;
//                        totalOrdersWithOverdue++;
//                    }
//                    if (hasOverdue && "已结清".equals(plan.getRepayStatus())) {
//                        hasSettledAfterOverdue = true;
//                        invalidOrders++;
//                        log.error("❌ 订单 {} 期数 {} 存在逾期后结清的情况！", order.getOrderNo(), plan.getBillTenor());
//                    }
//                }
//
//                if (hasOverdue && hasSettledAfterOverdue) {
//                    // 输出详细信息用于调试
//                    log.error("订单 {} 详细还款计划:", order.getOrderNo());
//                    for (CustomerRepayPlan plan : plans) {
//                        log.error("  期数: {}, 状态: {}, 应还日期: {}",
//                                plan.getBillTenor(), plan.getRepayStatus(), plan.getDueDate());
//                    }
//                }
//            }
//        }
//
//        log.info("有逾期的订单数量: {}", totalOrdersWithOverdue);
//        if (invalidOrders == 0) {
//            log.info("✅ 逾期逻辑验证通过：没有逾期后结清的情况");
//        } else {
//            log.error("❌ 发现 {} 个订单存在逾期后结清的情况，bug未完全修复！", invalidOrders);
//        }
//    }
//
//    /**
//     * 验证Vintage逾期率
//     */
//    private void validateVintageRates(Map<String, DataGenerator.VintageAnalysis> vintageAnalysis) {
//        log.info("=== 验证Vintage逾期率 ===");
//
//        boolean allValid = true;
//        for (DataGenerator.VintageAnalysis analysis : vintageAnalysis.values()) {
//            BigDecimal rate90Plus = analysis.getOverdue90PlusRate();
//            if (rate90Plus != null) {
//                double rate = rate90Plus.doubleValue();
//                if (rate >= 3.0 && rate <= 7.0) {
//                    log.info("✓ Vintage {} 90+逾期率: {:.2f}%", analysis.getVintage(), rate);
//                } else {
//                    log.warn("警告：Vintage {} 90+逾期率: {:.2f}% 不在预期范围(3%-7%)",
//                            analysis.getVintage(), rate);
//                    allValid = false;
//                }
//            }
//        }
//
//        if (allValid) {
//            log.info("✓ 所有Vintage逾期率都在预期范围内");
//        }
//    }
//}